import { contextBridge, ipcRenderer } from 'electron';

/**
 * Electron 预加载脚本
 * 在渲染进程中提供安全的 API 接口
 */

/**
 * 创建安全的 API 接口
 */
const photosAPI = {
  // 应用信息
  async getAppInfo() {
    return await ipcRenderer.invoke('app:getVersion');
  },

  // 对话框 - 根级别方法（向后兼容）
  async showMessageBox(options: any) {
    return await ipcRenderer.invoke('dialog:show-message-box', options);
  },

  // 对话框
  dialog: {
    async showMessageBox(options: any) {
      return await ipcRenderer.invoke('dialog:show-message-box', options);
    },
    
    async showOpenDialog(options: any) {
      return await ipcRenderer.invoke('dialog:show-open-dialog', options);
    },
    
    async openDirectory(options?: any) {
      return await ipcRenderer.invoke('dialog:open-directory', options);
    }
  },

  // 文件系统
  fs: {
    async readFile(filePath: string) {
      return await ipcRenderer.invoke('fs:read-file', filePath);
    },
    
    async writeFile(filePath: string, data: any) {
      return await ipcRenderer.invoke('fs:write-file', filePath, data);
    },
    
    async exists(filePath: string) {
      return await ipcRenderer.invoke('fs:exists', filePath);
    },
    
    async readdir(dirPath: string) {
      return await ipcRenderer.invoke('fs:readdir', dirPath);
    },
    
    async stat(filePath: string) {
      return await ipcRenderer.invoke('fs:stat', filePath);
    },
    
    async scanDirectory(path: string) {
      return await ipcRenderer.invoke('fs:scan-directory', path);
    }
  },

  // 数据库操作
  db: {
    async getPhotos(options?: any) {
      return await ipcRenderer.invoke('db:get-photos', options);
    },
    
    async addPhoto(photo: any) {
      return await ipcRenderer.invoke('db:add-photo', photo);
    },
    
    async updatePhoto(id: string, updates: any) {
      return await ipcRenderer.invoke('db:update-photo', id, updates);
    },
    
    async deletePhoto(id: string) {
      return await ipcRenderer.invoke('db:delete-photo', id);
    },
    
    async searchPhotos(query: string) {
      return await ipcRenderer.invoke('db:search-photos', query);
    },
    
    async importPhotos(photos: any[]) {
      return await ipcRenderer.invoke('db:import-photos', photos);
    }
  },

  // 缩略图生成
  thumbnail: {
    async generate(filePath: string, size?: number) {
      return await ipcRenderer.invoke('thumbnail:generate', filePath, size);
    },
    
    async getPath(filePath: string, size?: number) {
      return await ipcRenderer.invoke('thumbnail:get-path', filePath, size);
    }
  },

  // 元数据提取
  metadata: {
    async extract(filePath: string) {
      return await ipcRenderer.invoke('metadata:extract', filePath);
    }
  },

  // 导入功能
  async importFolders(folderPaths: string[]) {
    return await ipcRenderer.invoke('import:folders', folderPaths);
  },

  async cancelImport() {
    return await ipcRenderer.invoke('import:cancel');
  },

  // 事件监听
  onImportProgress(callback: (data: any) => void) {
    const wrappedCallback = (_event: Electron.IpcRendererEvent, data: any) => {
      callback(data);
    };
    
    ipcRenderer.on('import:progress', wrappedCallback);
    
    // 返回取消监听的函数
    return () => {
      ipcRenderer.removeListener('import:progress', wrappedCallback);
    };
  },

  onPhotoAdded(callback: (data: any) => void) {
    const wrappedCallback = (_event: Electron.IpcRendererEvent, data: any) => {
      callback(data);
    };
    
    ipcRenderer.on('photo:added', wrappedCallback);
    
    return () => {
      ipcRenderer.removeListener('photo:added', wrappedCallback);
    };
  },

  onPhotoUpdated(callback: (data: any) => void) {
    const wrappedCallback = (_event: Electron.IpcRendererEvent, data: any) => {
      callback(data);
    };
    
    ipcRenderer.on('photo:updated', wrappedCallback);
    
    return () => {
      ipcRenderer.removeListener('photo:updated', wrappedCallback);
    };
  },

  onPhotoDeleted(callback: (data: any) => void) {
    const wrappedCallback = (_event: Electron.IpcRendererEvent, data: any) => {
      callback(data);
    };
    
    ipcRenderer.on('photo:deleted', wrappedCallback);
    
    return () => {
      ipcRenderer.removeListener('photo:deleted', wrappedCallback);
    };
  },

  // 窗口控制
  window: {
    async minimize() {
      return await ipcRenderer.invoke('window:minimize');
    },
    
    async maximize() {
      return await ipcRenderer.invoke('window:maximize');
    },
    
    async close() {
      return await ipcRenderer.invoke('window:close');
    },
    
    async isMaximized() {
      return await ipcRenderer.invoke('window:is-maximized');
    }
  },

  // 系统信息
  system: {
    async getPlatform() {
      return await ipcRenderer.invoke('system:get-platform');
    },

    async getVersion() {
      return await ipcRenderer.invoke('system:get-version');
    }
  },

  /**
   * 监听来自主进程的消息
   */
  on(channel: string, callback: (...args: any[]) => void) {
    const wrappedCallback = (_event: Electron.IpcRendererEvent, ...args: any[]) => {
      callback(...args);
    };
    
    ipcRenderer.on(channel, wrappedCallback);
    
    // 返回取消监听的函数
    return () => {
      ipcRenderer.removeListener(channel, wrappedCallback);
    };
  },

  /**
   * 移除事件监听器
   */
  off(channel: string, callback?: (...args: any[]) => void) {
    if (callback) {
      ipcRenderer.removeListener(channel, callback);
    } else {
      ipcRenderer.removeAllListeners(channel);
    }
  }
};

/**
 * 暴露安全的 API 到渲染进程
 */
contextBridge.exposeInMainWorld('photosAPI', photosAPI);

/**
 * 开发环境下的调试信息
 */
if (process.env.NODE_ENV === 'development') {
  console.log('预加载脚本已加载');
  console.log('可用的 API:', Object.keys(photosAPI));
}

/**
 * 处理未捕获的错误
 */
(globalThis as any).addEventListener('error', (event: any) => {
  console.error('渲染进程错误:', event.error);
  ipcRenderer.send('renderer:error', {
    message: event.error?.message,
    stack: event.error?.stack,
    filename: event.filename,
    lineno: event.lineno,
    colno: event.colno
  });
});

/**
 * 处理未处理的 Promise 拒绝
 */
(globalThis as any).addEventListener('unhandledrejection', (event: any) => {
  console.error('未处理的 Promise 拒绝:', event.reason);
  ipcRenderer.send('renderer:unhandled-rejection', {
    reason: event.reason,
    promise: event.promise
  });
});